home *** CD-ROM | disk | FTP | other *** search
/ MacWorld 1999 February / Macworld (1999-02).dmg / Shareware World / Shareware Feature / NetPresenz 4.1 / Showcase / tricky / java / Life / Life.java next >
Encoding:
Java Source  |  1996-09-05  |  4.9 KB  |  252 lines  |  [TEXT/CWIE]
  1. /*
  2.     Example applet of Conway's Life.
  3.     ©1996 Peter N Lewis <peter@stairways.com.au>
  4.     Written for Metrowerks
  5.     
  6.     Feel free to use this source code in any way.
  7. */
  8.  
  9. package au.com.peter.example;
  10.  
  11. import java.awt.*;
  12. import java.applet.Applet;
  13.  
  14.  
  15. public class Life extends Applet
  16. {
  17.     public void init()
  18.     {
  19.         Board p;
  20.         Checkbox c;
  21.         
  22.         setLayout( new BorderLayout() );
  23.         
  24.         c = new Checkbox( "Running" );
  25.         c.setState( true );
  26.         add( "North", c );
  27.         p = new Board( 10, 10, 100, 100, c);
  28.         add( "Center", p );
  29.  
  30.         resize(300, 300);
  31.         //p.repaint();
  32.         p.start();
  33.     }  // end init()
  34.  
  35.     public static void main(String args[])
  36.     {
  37.         com.metrowerks.AppletFrame.startApplet("au.com.peter.example.Life", "Life", args);
  38.     }
  39.  
  40. }
  41.  
  42.  
  43. class Board extends Canvas implements Runnable {
  44.     
  45.     int x_max, y_max;
  46.     Checkbox running;
  47.     boolean board[][];
  48.     private boolean temp_board[][];
  49.     
  50.     public Board( int x_max, int y_max, int x_size, int y_size, Checkbox running ) {
  51.         this.x_max = x_max;
  52.         this.y_max = y_max;
  53.         this.board = new boolean[x_max][y_max];
  54.         this.temp_board = new boolean[x_max][y_max];
  55.         this.running = running;
  56.         
  57.         this.board[2][2] = true;
  58.         this.board[2][3] = true;
  59.         this.board[2][4] = true;
  60.         this.board[1][4] = true;
  61.         this.board[0][3] = true;
  62.         
  63.         resize( x_size, y_size );
  64.         repaint();
  65.     }
  66.     
  67.     private int XtoCell( int x ) {
  68.         int x_total = bounds().width+1;
  69.         
  70.         return x * x_max / x_total;
  71.     }
  72.     
  73.     private int YtoCell( int y ) {
  74.         int y_total = bounds().height+1;
  75.         
  76.         return y * y_max / y_total;
  77.     }
  78.     
  79.     private void PaintCell( Graphics g, Rectangle b, int x, int y ) {
  80.         int x_total = b.width -1;
  81.         int y_total = b.height -1;
  82.         int left, right, top, bottom, width, height;
  83.         
  84.         left = x * x_total / x_max;
  85.         right = (x+1) * x_total / x_max;
  86.         width = right - left;
  87.         top = y * y_total / y_max;
  88.         bottom = (y+1) * y_total / y_max;
  89.         height = bottom - top;
  90.         
  91.         g.setColor(Color.black);
  92.         if ( board[x][y] ) {
  93.             g.fillRect(left, top, width, height);
  94.         } else {
  95.             g.drawRect(left, top, width, height);
  96.             g.clearRect(left+1, top+1, width-1, height-1);
  97.         }
  98.     }
  99.     
  100.     private void PaintCell( int x, int y ) {
  101.         Graphics g = getGraphics();
  102.         
  103.         if ( g != null ) {
  104.             PaintCell( g, bounds(), x, y );
  105.         }
  106.     }
  107.     
  108.     public void paint( Graphics g ) {
  109.         Rectangle b = bounds();
  110.  
  111.         for ( int y = 0; y < y_max; y++ ) {
  112.             for ( int x = 0; x < x_max; x++ ) {
  113.                 PaintCell( g, b, x, y );
  114.             }
  115.         }
  116.     }
  117.     
  118.     boolean dragging = false;
  119.     
  120.     public synchronized void Propagate() {
  121.         
  122.         if ( dragging ) {
  123.             return;
  124.         }
  125.         
  126.         for ( int y = 0; y < y_max; y++ ) {
  127.             for ( int x = 0; x < x_max; x++ ) {
  128.                 int sum = 0;
  129.                 
  130.                 for ( int dy = -1; dy <= 1; dy++ ) {
  131.                     for ( int dx = -1; dx <= 1; dx++ ) {
  132.                         if ( dx != 0 || dy != 0 ) {
  133.                             int tx = x + dx;
  134.                             int ty = y + dy;
  135.                             
  136.                             if ( tx < 0 ) {
  137.                                 tx = x_max - 1;
  138.                             }
  139.                             if ( tx >= x_max ) {
  140.                                 tx = 0;
  141.                             }
  142.                             if ( ty < 0 ) {
  143.                                 ty = y_max - 1;
  144.                             }
  145.                             if ( ty >= y_max ) {
  146.                                 ty = 0;
  147.                             }
  148.                             if ( board[tx][ty] ) {
  149.                                 sum++;
  150.                             }
  151.                         }
  152.                     }
  153.                 }
  154.                 
  155.                 if ( board[x][y] && ((sum<2) || (sum>=4)) ) {
  156.                     temp_board[x][y] = false;
  157.                 } else if ( !board[x][y] && sum==3 ) {
  158.                     temp_board[x][y] = true;
  159.                 } else {
  160.                     temp_board[x][y] = board[x][y];
  161.                 }
  162.             }
  163.         }
  164.  
  165.         Graphics g = getGraphics();
  166.         Rectangle b = bounds();
  167.  
  168.         if ( g != null ) {
  169.             for ( int y = 0; y < y_max; y++ ) {
  170.                 for ( int x = 0; x < x_max; x++ ) {
  171.                     if ( temp_board[x][y] != board[x][y] ) {
  172.                         board[x][y] = temp_board[x][y];
  173.                         PaintCell( g, b, x, y );
  174.                     }
  175.                 }
  176.             }
  177.         }
  178.     }
  179.     
  180.     int drag_x;
  181.     int drag_y;
  182.     boolean inside;
  183.     
  184.     private void CheckInside( int x, int y ) {
  185.         int tmp_x = XtoCell( x );
  186.         int tmp_y = YtoCell( y );
  187.         boolean tmp_inside = (tmp_x == drag_x) && (tmp_y == drag_y);
  188.         
  189.         if ( tmp_inside != inside ) {
  190.             inside = tmp_inside;
  191.             board[drag_x][drag_y] = !board[drag_x][drag_y];
  192.             PaintCell( drag_x, drag_y );
  193.         }
  194.     }
  195.     
  196.     public boolean mouseDown( Event e, int x, int y ) {
  197.         drag_x = XtoCell( x );
  198.         drag_y = YtoCell( y );
  199.         dragging = (0 <= drag_x) && (drag_x < x_max) && (0 <= drag_y) && (drag_y < y_max);
  200.         if ( dragging ) {
  201.             synchronized ( this ) {
  202.                 inside = true;
  203.                 board[drag_x][drag_y] = !board[drag_x][drag_y];
  204.                 PaintCell( drag_x, drag_y );
  205.             }
  206.         }
  207.         return true;
  208.     }
  209.     
  210.     public boolean mouseUp( Event e, int x, int y ) {
  211.         if ( dragging ) {
  212.             CheckInside( x, y );
  213.             dragging = false;
  214.         }
  215.         return true;
  216.     }
  217.     
  218.     public boolean mouseDrag( Event e, int x, int y ) {
  219.         if ( dragging ) {
  220.             CheckInside( x, y );
  221.         }
  222.         return true;
  223.     }
  224.     
  225.     Thread thread = null;
  226.     
  227.     public void start() {
  228.         if ( thread == null ) {
  229.             thread = new Thread( this );
  230.             thread.start();
  231.         }
  232.     }
  233.     
  234.     public void stop() {
  235.         if ( thread != null && thread.isAlive() ) {
  236.             thread.stop();
  237.         }
  238.         thread = null;
  239.     }
  240.     
  241.     public void run() {
  242.         while (true) {
  243.             try { Thread.sleep(25); } catch (InterruptedException e){};
  244.             if ( isVisible() && running.getState() ) {
  245.                 Propagate();
  246.             }
  247.         }
  248.     }
  249.     
  250. }
  251.  
  252.